#include "JobScheduler.h"
#include "ExampleJobs.h"
#include "Logger.h"
#include <iostream>
#include <vector>
#include <memory>
#include <thread>
#include <chrono>
#include <sstream>
#include <atomic>

// 用于定期获取线程状态的函数
void printThreadStatus(JobScheduler& scheduler, const std::string& schedulerName, std::atomic<bool>& stopFlag) {
    int counter = 0;
    while (!stopFlag.load()) {
        // 每5秒执行一次
        std::this_thread::sleep_for(std::chrono::seconds(5));
        
        // 检查是否需要停止
        if (stopFlag.load()) {
            break;
        }
        
        // 获取线程状态
        auto threadStatus = scheduler.getThreadStatus();
        
        // 输出日志
        std::ostringstream oss;
        oss << schedulerName << " - 线程状态检查 #" << ++counter << " - 线程数量: " << threadStatus.size();
        Logger::getInstance().info(oss.str());
        
        // 输出每个线程的详细信息
        for (const auto& status : threadStatus) {
            std::ostringstream detailOss;
            detailOss << "  线程 " << status.id << " (" << status.name << ") - 状态: " << status.status 
                      << ", 任务数量: " << status.jobCount;
            Logger::getInstance().info(detailOss.str());
        }
    }
}

int main() {
    std::cout << "智能任务调度器测试程序" << std::endl;
    
    // 初始化日志系统
    Logger& logger = Logger::getInstance();
    logger.setLogLevel(LogLevel::DEBUG);
    logger.info("开始测试智能任务调度器");
    
    // 创建任务列表
    std::vector<std::shared_ptr<JobInterface>> jobs;
    
    // 添加不同类型的示例任务
    jobs.push_back(std::make_shared<SimpleJob>("Job1", std::chrono::milliseconds(1000), std::chrono::milliseconds(100)));
    jobs.push_back(std::make_shared<SimpleJob>("Job2", std::chrono::milliseconds(2000), std::chrono::milliseconds(100)));
    jobs.push_back(std::make_shared<HeavyJob>("Job3", std::chrono::milliseconds(5000), std::chrono::milliseconds(300)));
    jobs.push_back(std::make_shared<RandomJob>("Job4", std::chrono::milliseconds(3000), std::chrono::milliseconds(200)));
    jobs.push_back(std::make_shared<ExceptionJob>("Job5", std::chrono::milliseconds(4000), std::chrono::milliseconds(100)));
    
    // 测试自动策略
    std::cout << "\n=== 测试自动调度策略 ===" << std::endl;
    logger.info("使用自动调度策略初始化调度器");
    
    // 创建调度器
    JobScheduler scheduler;
    
    // 设置任务
    scheduler.setJobs(jobs);
    
    // 初始化调度器
    scheduler.initialize();
    
    // 启动线程状态监控线程
    std::atomic<bool> stopFlag1(false);
    std::thread statusThread1(printThreadStatus, std::ref(scheduler), "自动策略", std::ref(stopFlag1));
    
    // 运行一段时间
    std::this_thread::sleep_for(std::chrono::seconds(15));
    
    // 获取统计信息
    auto stats = scheduler.getJobStats();
    std::cout << "\n任务统计信息:" << std::endl;
    for (const auto& stat : stats) {
        std::cout << "任务 " << stat.jobId 
                  << " - 执行次数: " << stat.executionCount
                  << ", 平均时间: " << stat.averageTimeMs << "ms"
                  << ", 最大时间: " << stat.maxTimeMs << "ms"
                  << ", 最小时间: " << stat.minTimeMs << "ms"
                  << ", 超时次数: " << stat.timeoutCount << std::endl;
    }
    
    // 关闭调度器
    scheduler.shutdown();
    
    // 停止状态监控线程
    stopFlag1.store(true);
    if (statusThread1.joinable()) {
        statusThread1.join();
    }
    
    // 测试手动策略
    std::cout << "\n=== 测试手动调度策略 ===" << std::endl;
    logger.info("使用手动调度策略初始化调度器");
    
    // 创建新的调度器实例
    JobScheduler manualScheduler;
    
    // 创建手动策略分组
    std::vector<std::vector<std::string>> manualGroups = {
        {"Job1", "Job2"},  // 线程1处理Job1和Job2
        {"Job3", "Job4"},  // 线程2处理Job3和Job4
        {"Job5"}            // 线程3处理Job5
    };
    
    // 设置任务和策略
    manualScheduler.setJobs(jobs);
    manualScheduler.setManualStrategy(manualGroups);
    
    // 初始化
    manualScheduler.initialize();
    
    // 启动线程状态监控线程
    std::atomic<bool> stopFlag2(false);
    std::thread statusThread2(printThreadStatus, std::ref(manualScheduler), "手动策略", std::ref(stopFlag2));
    
    // 运行一段时间
    std::this_thread::sleep_for(std::chrono::seconds(15));
    
    // 获取统计信息\n    stats = manualScheduler.getJobStats();\n    std::cout << \"\\n任务统计信息:\" << std::endl;\n    for (const auto& stat : stats) {\n        std::cout << \"任务 \" << stat.jobId \n                  << \" - 执行次数: \" << stat.executionCount\n                  << \", 平均时间: \" << stat.averageTimeMs << \"ms\"\n                  << \", 最大时间: \" << stat.maxTimeMs << \"ms\"\n                  << \", 最小时间: \" << stat.minTimeMs << \"ms\"\n                  << \", 超时次数: \" << stat.timeoutCount << std::endl;\n    }
    
    // 关闭调度器
    manualScheduler.shutdown();
    
    // 停止状态监控线程
    stopFlag2.store(true);
    if (statusThread2.joinable()) {
        statusThread2.join();
    }
    
    logger.info("测试程序结束");
    std::cout << "\n测试程序结束" << std::endl;
    
    return 0;
}